﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdio.h>
using namespace std;

//template<class T>
//class DeleteArray
//{
//public:
//	void operator()(T* ptr)
//	{
//		delete[] ptr;
//	}
//};

//class Fclose
//{
//public:
//	void operator()(FILE* ptr)
//	{
//		cout << "fclose:" << ptr << endl;
//		fclose(ptr);
//	}
//};
//
//struct Date
//{
//	int _year;
//	int _month;
//	int _day;
//	Date(int year = 1, int month = 1, int day = 1)
//		:_year(year)
//		, _month(month)
//		, _day(day)
//	{
//	}
//	~Date()
//	{
//		cout << "~Date()" << endl;
//	}
//};
//
//int main()
//{
//	shared_ptr<Date> sp1(new Date(2024, 5, 6));
//	shared_ptr<Date> sp2 = make_shared<Date>(2027, 6, 7);
//	shared_ptr<Date> sp4;
//
//	if (sp1.operator bool())
//
//	if (sp1)
//		cout << "sp1 is not nullptr" << endl;
//	if (sp4)
//		cout << "sp1 is nullptr" << endl;
//	
//
//	// 报错 
//	//shared_ptr<Date> sp5 = new Date(2024, 9, 11);
//	//unique_ptr<Date> sp6 = new Date(2024, 9, 11);
//
//	return 0;
//}



//int main()
//{
//	// 解决⽅案2 
//
//	// 实现其他资源管理的删除器 
//	shared_ptr<FILE> sp5(fopen("Test.cpp", "r"), Fclose());
//	shared_ptr<FILE> sp6(fopen("Test.cpp", "r"), [](FILE* ptr) {
//		cout << "fclose:" << ptr << endl;
//		fclose(ptr);
//		});
//
//	
//	//// lambda表达式做删除器 
//	//auto delArrOBJ = [](Date* ptr) {delete[] ptr; };
//	//unique_ptr<Date, decltype(delArrOBJ)> up4(new Date[5], delArrOBJ);
//	//shared_ptr<Date> sp4(new Date[5], delArrOBJ);
//
//	// 仿函数对象做删除器 
//	//unique_ptr<Date, DeleteArray<Date>> up2(new Date[5], DeleteArray<Date>());
//	// unique_ptr和shared_ptr⽀持删除器的⽅式有所不同 
//	// unique_ptr是在类模板参数⽀持的，shared_ptr是构造函数参数⽀持的 
//	// 这⾥没有使⽤相同的⽅式还是挺坑的 
//	// 使⽤仿函数unique_ptr可以不在构造函数传递，因为仿函数类型构造的对象直接就可以调⽤ 
//	// 但是下⾯的函数指针和lambda的类型不可以 
//	//unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]);
//	//shared_ptr<Date> sp2(new Date[5], DeleteArray<Date>());
//
//
//
//}



//int main()
//{
//
//	shared_ptr<Date> sp1(new Date);
//	// ⽀持拷⻉ 
//	shared_ptr<Date> sp2(sp1);
//	shared_ptr<Date> sp3(sp2);
//	cout << sp1.use_count() << endl;
//	sp1->_year++;
//	cout << sp1->_year << endl;
//	cout << sp2->_year << endl;
//	cout << sp3->_year << endl;
//
//	// ⽀持移动，但是移动后sp1也悬空，所以使⽤移动要谨慎 
//	shared_ptr<Date> sp4(move(sp1));
//
//
//
//	//unique_ptr<Date> up1(new Date);
//	//// 不⽀持拷⻉ 
//	////unique_ptr<Date> up2(up1);
//	//// ⽀持移动，但是移动后up1也悬空，所以使⽤移动要谨慎 
//	//unique_ptr<Date> up3(move(up1));
//
//
//
//	return 0;
//}

//template<class T>
//class add
//{
//public:
//	void operator()(T* date)
//	{
//		delete[] date;
//	}
//};
//
//int main()
//{
//	//auto_ptr<Date> ap1(new Date);
//	//// 拷⻉时，管理权限转移，被拷⻉对象ap1悬空 
//	//auto_ptr<Date> ap2(ap1);
//	//// 空指针访问，ap1对象已经悬空 
//	//ap1->_year++;
//
//	//unique_ptr<Date> up1(new Date);
//	////不⽀持拷⻉
//	//unique_ptr<Date> up2(up1);
//	//
//	unique_ptr<Date, add<Date>> up1(new Date[5]);
//
//
//	return 0;
//}


struct Date
{
	int _year;
	int _month;
	int _day;
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}
};

namespace bit
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{
		}
		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{
			// 管理权转移 
			sp._ptr = nullptr;
		}
		auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			// 检测是否为⾃⼰给⾃⼰赋值
			if (this != &ap)
			{
				// 释放当前对象中资源 
				if (_ptr)
					delete _ptr;
				// 转移ap中资源到当前对象中 
				_ptr = ap._ptr;
				ap._ptr = NULL;
			}
			return *this;
		}
		~auto_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		// 像指针⼀样使⽤ 
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
}

int main()
{

}